package collectionDemo;


import arithmetic.A_05_PriorityQueue;
import arithmetic2.TreeNode;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

/**
 * @author Ajie
* @date 7/19/21
 * @function 详细研究 PriorityQueue
 * @see A_05_PriorityQueue
 *
 * //PriorityQueue默认是一个小顶堆， poll 出最小值 。默认 compare (Integer o1, Integer o2)
 *             public int compare(Integer o1, Integer o2) {
 * //                return o1-o2; //默认小顶堆。
 *                 return o2 - o1;//大顶堆。
 *             }
 * 可以通过传入自定义的Comparator函数来实现大顶堆
 *
 * PriorityQueue 可以 add 2 个相同的数据进入 队列。不去重。
 * 自定义 class 需要重写 compare
 *          TreeNode treeNode = new TreeNode(2);
 *         treeNodePriorityQueue.offer(treeNode);
 *         treeNodePriorityQueue.offer(treeNode);//size  2 .
 *
 */
public class PriorityQueueDemo {
    public static void main(String[] args) {
        //默认是一个小顶堆, poll 出 最小值。o1-o2;
        Queue<Integer> mQueue = new PriorityQueue<>(3, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
//                return o1-o2; //默认小顶堆。
                return o2 - o1;//大顶堆。
            }
        });
        mQueue.add(3);
        mQueue.add(4);
        mQueue.add(2);
        mQueue.add(1);

        System.out.println("A_05_PriorityQueue:main:mQueue.poll:"+mQueue.poll());


        int n = 10;
        Queue<int[]> queue = new PriorityQueue<>((a, b) -> {
            if (a[2] != b[2]) {//step a - b.
                return a[2] - b[2];
            } else {
                int manhattenDistanceA = (n - 1 - a[0]) + (n - 1 - a[1]);
                int manhattenDistanceB = (n - 1 - b[0]) + (n - 1 - b[1]);
                return manhattenDistanceA - manhattenDistanceB;
            }

        });
        //The above queue stores a,b,c where c is the least distance from source

        queue.offer(new int[]{0, 0, 1});//step 1,优先级考虑，第几步，
        queue.offer(new int[]{0, 0, 1});//step 1,优先级考虑，第几步，

        System.out.println("PriorityQueueDemo:main:queue.size:"+queue.size());//2

        PriorityQueue<TreeNode> treeNodePriorityQueue = new PriorityQueue<>(new Comparator<TreeNode>() {
            @Override
            public int compare(TreeNode o1, TreeNode o2) {
                return o1.val - o2.val;
            }
        });
        TreeNode treeNode = new TreeNode(2);
        treeNodePriorityQueue.offer(treeNode);
        treeNodePriorityQueue.offer(treeNode);//size  2 .






        // Exception --> TreeNode cannot be cast to java.lang.Comparable
        System.out.println("PriorityQueueDemo:main:same node size:"+treeNodePriorityQueue.size());
    }
}
